/*
 * State_Machine.h
 *
 *  Created on: Oct 2, 2024
 *      Author: Grasping
 */

#ifndef MY_INC_APP_APP_ACLOAD_CURRSTATEMACHINE_H_
#define MY_INC_APP_APP_ACLOAD_CURRSTATEMACHINE_H_
#include "MY_INC/APP/APP_ACLoad_PRotection.h"
#include "MY_INC/APP/APP_ACLoad_Pwm.h"
#include "MY_INC/APP/APP_Init.h"
#include "MY_INC/LC/LC_SYS.h"
/*---------- 并网状态处理函数声明 ----------*/
static inline void Current_Loop(InterruptController *InterruptController);     // 电流环状态机主控函数
static inline void RunCurrLoop_State_Stop(InterruptController *controller);    // 停止状态处理
static inline void RunCurrLoop_State_Idle(InterruptController *controller);    // 空闲状态处理
static inline void RunCurrLoop_State_Running(InterruptController *controller); // 运行状态处理
static inline void RunCurrLoop_State_Machine(InterruptController *controller); // 状态机主控函数
static inline void RunCurrLoop_State_ProcessControl(InterruptController *Controller);
/*==================================状态机===================================*/
/*---------- 状态机主控函数 ----------*/
// 参数：系统指针，触发事件 (参数类型修正)
// 功能：根据当前状态调用对应的处理函数

static inline void RunCurrLoop_State_ProcessControl(InterruptController *Controller)
{

    // 如果启动标志被激活
    if (Controller->loop_sm.start_flag == Activated)
    {
        Controller->loop_sm.event = EVENT_LOOP_ENABLE; // 设置为使能事件
        Controller->loop_sm.start_flag = Nonactivated; // 清除启动标志
    }

    // 如果停止标志被激活
    if (Controller->loop_sm.stop_flag == Activated)
    {
        Controller->loop_sm.event = EVENT_LOOP_STOP;  // 设置为停止事件
        Controller->loop_sm.stop_flag = Nonactivated; // 清除停止标志
        Controller->param.il_ref = 0.0f;              // 将参考电流设为0
    }
    RunCurrLoop_State_Machine(Controller); // 运行电流环状态机
    SPWM_Control_Inline(&Controller->pwm); // 传递整个 controller 和 PWM控制
}

// static inline void RunCurrLoop_State_ProcessControl(InterruptController *Controller)
// {
//     // 对传入的指针进行空值检查，这是一个好的编程习惯
//     if (Controller == NULL)
//     {
//         // 可以在这里添加错误处理，例如日志记录或返回错误码
//         Uart1_Printf("Error: Control is NULL in pr_processControl.\n");
//         return;
//     }
//     // /**********软件保护处理********************/
//     // Interrupt_Protection(Controller); // 保护函数
//     // /**********环路处理********************/
//     // SignalAnalysisr_ProcessSample_Inline(Controller->param.SignalAnalysisr,
//     //                                      Controller->param.vo_actual); // 检测有效值
//     // 根据设备的当前状态进行不同的处理
//     switch (Controller->monitor.device_state)
//     {
//     case DEVICE_STATE_NORMAL:
//         // 正常状态下，默认事件为无事件
//         Controller->loop_sm.event = EVENT_LOOP_NONE;

//         // 如果启动标志被激活
//         if (Controller->loop_sm.start_flag == Activated)
//         {
//             Controller->loop_sm.event = EVENT_LOOP_ENABLE; // 设置为使能事件
//             Controller->loop_sm.start_flag = Nonactivated; // 清除启动标志
//         }

//         // 如果停止标志被激活
//         if (Controller->loop_sm.stop_flag == Activated)
//         {
//             Controller->loop_sm.event = EVENT_LOOP_STOP;  // 设置为停止事件
//             Controller->loop_sm.stop_flag = Nonactivated; // 清除停止标志
//             Controller->param.il_ref = 0.0f;              // 将参考电流设为0
//         }
//         break;

//     case DEVICE_STATE_FAULT: // 设备处于故障状态
//         // 故障状态下，清除启动标志，默认事件为无事件
//         Controller->loop_sm.start_flag = Nonactivated;
//         Controller->loop_sm.event = EVENT_LOOP_NONE;

//         // 如果停止标志被激活 (即便在故障状态下，停止指令也应被响应)
//         if (Controller->loop_sm.stop_flag == Activated)
//         {
//             Controller->loop_sm.event = EVENT_LOOP_STOP;  // 设置为停止事件
//             Controller->loop_sm.stop_flag = Nonactivated; // 清除停止标志
//             Controller->param.il_ref = 0.0f;              // 将参考电流设为0
//         }
//         break;

//     case DEVICE_STATE_HALT: // 设备处于暂停/停止状态
//         // 暂停状态下，清除启动和停止标志，强制设置为停止事件
//         Controller->loop_sm.start_flag = Nonactivated;
//         Controller->loop_sm.stop_flag = Nonactivated;
//         Controller->loop_sm.event = EVENT_LOOP_STOP;
//         break;

//     default:
//         // 处理未预期的设备状态，可添加日志或默认行为
//         break;
//     } // Test_Mode == 0
//     RunCurrLoop_State_Machine(Controller); // 运行电流环状态机
//     SPWM_Control_Inline(&Controller->pwm); // 传递整个 controller 和 PWM控制
// }
static inline void Current_Loop(InterruptController *InterruptController)
{
    // 获取角度 (访问 LoopParameter 成员)
    InterruptController->param.phase_count = (InterruptController->param.phase_count + 1) % SIZE_SINE;
    InterruptController->param.theta = InterruptController->param.phase_count * SIZE_COEFFICIENT;
    Cordic_SinCos_Inline(InterruptController->param.theta, &InterruptController->param.sin_val,
                         &InterruptController->param.cos_val);
    VariableStep_Update_Inline(
        InterruptController->param.iref,
        InterruptController->param.il_ref * _SQRT2 *
            1.071428571428f); // 访问 il.ref ,1.0714285714是一个补偿，补偿输出电流未达到的部分，有电压环就不需要补偿
    // 电流环计算 (访问 LoopParameter 成员)
    InterruptController->pwm.mod_wave =
        (PMRdiff_Calculate_Inline(InterruptController->param.pr_i,
                                  InterruptController->param.iref->currentTemp * InterruptController->param.sin_val,
                                  InterruptController->param.il_actual) +
         InterruptController->param.vo_actual) /
        InterruptController->param.udc_actual;
}
static inline void RunCurrLoop_State_Machine(InterruptController *controller)
{
    // 新的 LoopStateMachine 结构体只有 current_state，直接根据它进行调度
    // 不再有 Last_State 和 Next_State 的显式管理，状态函数直接更新 current_state
    switch (controller->loop_sm.current_state) // 访问 loop_sm.current_state
    {
    case STATE_STOP:
        RunCurrLoop_State_Stop(controller); // 传递整个 controller
        break;
    case STATE_IDLE:
        RunCurrLoop_State_Idle(controller); // 传递整个 controller
        break;
    case STATE_RUN:                            // 枚举名称从 STATE_RUN 改为 STATE_RUN
        RunCurrLoop_State_Running(controller); // 传递整个 controller
        break;
    default:                                        // 其他状态不处理
        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
        RunCurrLoop_State_Stop(controller);         // 传递整个 controller
    }
}
/*---------- 停止状态处理 ----------*/
// 参数类型修正，内部访问 loop_sm 和 param
static inline void RunCurrLoop_State_Stop(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_NONE: // 无事件
        /*用户处理*/
        Loop_Init(&controller->param);
        controller->param.phase_count = 0; // 重置 phase_count
        controller->param.theta = 0;
        /*状态切换*/
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    case EVENT_LOOP_STOP: // 停止事件
        /*用户处理*/
        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
        Loop_Init(&controller->param);              // 初始化环路参数
        /*状态切换*/
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    default:                                            // 其他事件不响应
        controller->pwm.pwm_en_flag = Nonactivated;     // 不允许PWM
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}
// 空闲状态处理 (参数类型修正，内部访问 loop_sm)
static inline void RunCurrLoop_State_Idle(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_ENABLE: // 环路开始事件
                            /*用户处理*/
        /*状态切换条件*/
        controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
        break;
    case EVENT_LOOP_STOP: // 停止事件
        /*用户处理*/
        /*状态切换条件*/
        controller->pwm.pwm_en_flag = Nonactivated;     // 不允许PWM
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    case EVENT_LOOP_NONE: // 无事件
        /*用户处理*/
        /*状态切换*/
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    default:                                            // 其他事件不响应
        controller->pwm.pwm_en_flag = Nonactivated;     // 不允许PWM
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}
/*---------- 运行状态处理 ----------*/
// 运行状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
static inline void RunCurrLoop_State_Running(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_STOP:                           // 停止事件
                                                    /*用户处理*/
        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
        /*状态切换*/
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    case EVENT_LOOP_NONE:                        // 无事件
        controller->pwm.pwm_en_flag = Activated; // 允许PWM
        Current_Loop(controller);                // 计算电流环 (访问 LoopParameter 成员)
        /*默认转移*/
        controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
        break;
    default:                                            // 其他事件不响应
        controller->pwm.pwm_en_flag = Nonactivated;     // 不允许PWM
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}

#endif /* INC_STATE_MACHINE_H_ */
